home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan).7z / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / internet / xip / iijppp.lzh / src / command.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-23  |  17.6 KB  |  806 lines
  1. /*
  2.  *        PPP User command processing module
  3.  *
  4.  *        Written by Toshiharu OHNO (tony-o@iij.ad.jp)
  5.  *
  6.  *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
  7.  *
  8.  * Redistribution and use in source and binary forms are permitted
  9.  * provided that the above copyright notice and this paragraph are
  10.  * duplicated in all such forms and that any documentation,
  11.  * advertising materials, and other materials related to such
  12.  * distribution and use acknowledge that the software was developed
  13.  * by the Internet Initiative Japan, Inc.  The name of the
  14.  * IIJ may not be used to endorse or promote products derived
  15.  * from this software without specific prior written permission.
  16.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19.  *
  20.  */
  21. #include <ctype.h>
  22. #include "fsm.h"
  23. #include "phase.h"
  24. #include "lcp.h"
  25. #include "ipcp.h"
  26. #include "modem.h"
  27. #include "command.h"
  28. #include "hdlc.h"
  29. #include "vars.h"
  30. #include <netdb.h>
  31. #include <sys/socket.h>
  32. #include <arpa/inet.h>
  33. #include <net/route.h>
  34. #include "os.h"
  35.  
  36. extern int  MakeArgs();
  37. extern void Cleanup(), TtyTermMode(), PacketMode();
  38. extern int  EnableCommand(), DisableCommand(), DisplayCommand();
  39. extern int  AcceptCommand(), DenyCommand();
  40. extern int  LoadCommand(), SaveCommand();
  41. extern int  ChangeParity(char *);
  42. extern int  SelectSystem();
  43. extern int  ShowRoute();
  44.  
  45. struct in_addr ifnetmask;
  46.  
  47. static int ShowCommand(), TerminalCommand(), QuitCommand();
  48. static int CloseCommand(), DialCommand(), DownCommand();
  49. static int SetCommand(), AddCommand(), DeleteCommand();
  50.  
  51. static int
  52. HelpCommand(list, argc, argv, plist)
  53. struct cmdtab *list;
  54. int argc;
  55. char **argv;
  56. struct cmdtab *plist;
  57. {
  58.   struct cmdtab *cmd;
  59.   int n;
  60.   char c;
  61.  
  62.   if (argc > 0) {
  63.     for (cmd = plist; cmd->name; cmd++) {
  64.       if (strcmp(cmd->name, *argv) == 0) {
  65.         printf("%s %s\n", cmd->name, cmd->syntax);
  66.         return(1);
  67.       }
  68.     }
  69.     return(1);
  70.   }
  71.   n = 0;
  72.   for (cmd = plist; cmd->func; cmd++) {
  73.     c = (n & 1)? '\n' : '\t';
  74.     if (cmd->name) {
  75.       printf("  %-8s: %-20s%c", cmd->name, cmd->helpmes, c);
  76.       n++;
  77.     }
  78.   }
  79.   if (n & 1)
  80.     printf("\n");
  81.   return(1);
  82. }
  83.  
  84. int
  85. IsInteractive()
  86. {
  87.   char *mes = NULL;
  88.  
  89.   if (mode & MODE_AUTO)
  90.     mes = "Working as auto mode.";
  91.   else if (mode & MODE_DIRECT)
  92.     mes = "Working as direct mode.";
  93.   else if (mode & MODE_DEDICATED)
  94.     mes = "Workring as dedicated mode.";
  95.   if (mes) {
  96.     printf("%s\n", mes);
  97.     return(0);
  98.   }
  99.   return(1);
  100. }
  101.  
  102. static int
  103. DialCommand(cmdlist, argc, argv)
  104. struct cmdtab *cmdlist;
  105. int argc;
  106. char **argv;
  107. {
  108.   if (LcpFsm.state > ST_CLOSED) {
  109.     printf("LCP state is [%s]\n", StateNames[LcpFsm.state]);
  110.     return(1);
  111.   }
  112.   if (!IsInteractive())
  113.     return(1);
  114.   modem = OpenModem(mode);
  115.   if (modem < 0) {
  116.     printf("failed to open modem.\n");
  117.     modem = 0;
  118.     return(1);
  119.   }
  120.   if (argc > 0) {
  121.     if (SelectSystem(*argv, CONFFILE) < 0) {
  122.       printf("%s: not found.\n", *argv);
  123.       return(1);
  124.     }
  125.   }
  126.   if (DialModem()) {
  127.     sleep(1);
  128.     ModemTimeout();
  129.     PacketMode();
  130.   }
  131.   return(1);
  132. }
  133.  
  134. static char StrOption[] = "option ..";
  135. static char StrRemote[] = "[remote]";
  136. char StrNull[] = "";
  137.  
  138. struct cmdtab Commands[] = {
  139.   { "accept",  NULL,    AcceptCommand,
  140.       "accept option request",    StrOption },
  141.   { "add",     NULL,    AddCommand,
  142.     "add route",            "dest mask gateway" },
  143.   { "close",   NULL,    CloseCommand,
  144.     "Close connection",        StrNull },
  145.   { "delete",  NULL,    DeleteCommand,
  146.       "delete route",            "dest gateway" },
  147.   { "deny",    NULL,    DenyCommand,
  148.       "Deny option request",        StrOption },
  149.   { "dial",    "call",  DialCommand,
  150.       "Dial and login",        StrRemote },
  151.   { "disable", NULL,    DisableCommand,
  152.       "Disable option",        StrOption },
  153.   { "display", NULL,    DisplayCommand,
  154.       "Display option configs",    StrNull },
  155.   { "enable",  NULL,    EnableCommand,
  156.       "Enable option",        StrOption },
  157.   { "load",    NULL,    LoadCommand,
  158.       "Load settings",        StrRemote },
  159.   { "save",    NULL,    SaveCommand,
  160.       "Save settings", StrNull },
  161.   { "set",     "setup", SetCommand,
  162.       "Set parameters",  "var value" },
  163.   { "show",    NULL,    ShowCommand,
  164.       "Show status and statictics", "var" },
  165.   { "term",    NULL,    TerminalCommand,
  166.       "Enter to terminal mode", StrNull },
  167.   { "quit",    "bye",   QuitCommand,
  168.       "Quit PPP program", StrNull },
  169.   { "help",    "?",     HelpCommand,
  170.     "Display this message", "[command]", (void *)Commands },
  171.   { NULL,      "down",  DownCommand,
  172.       "Generate down event",        StrNull },
  173.   { NULL,      NULL,    NULL },
  174. };
  175.  
  176. extern int ReportCcpStatus();
  177. extern int ReportLcpStatus();
  178. extern int ReportIpcpStatus();
  179. extern int ReportProtStatus();
  180. extern int ReportCompress();
  181. extern int ShowModemStatus();
  182. extern int ReportHdlcStatus();
  183. extern int ShowMemMap();
  184.  
  185. static char *LogLevelName[] = {
  186.   LM_PHASE, LM_CHAT, LM_LQM,   LM_LCP,
  187.   LM_TCPIP, LM_HDLC, LM_ASYNC,
  188. };
  189.  
  190. static int ShowDebugLevel()
  191. {
  192.   int i;
  193.  
  194.   printf("%02x: ", loglevel);
  195.   for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) {
  196.     if (loglevel & (1 << i))
  197.       printf("%s ", LogLevelName[i]);
  198.   }
  199.   printf("\n");
  200.   return(1);
  201. }
  202.  
  203. static int ShowEscape()
  204. {
  205.   int code, bit;
  206.  
  207.   if (EscMap[32]) {
  208.     for (code = 0; code < 32; code++) {
  209.       if (EscMap[code]) {
  210.         for (bit = 0; bit < 8; bit++) {
  211.           if (EscMap[code] & (1<<bit)) {
  212.             printf(" 0x%02x", (code << 3) + bit);
  213.           }
  214.         }
  215.       }
  216.     }
  217.     printf("\n");
  218.   }
  219.   return(1);
  220. }
  221.  
  222. static int ShowTimeout()
  223. {
  224.   printf(" Idle Timer: %d secs   LQR Timer: %d secs\n",
  225.     VarIdleTimeout, VarLqrTimeout);
  226.   return(1);
  227. }
  228.  
  229. static int ShowAuthKey()
  230. {
  231.   printf("AuthName = %s\n", VarAuthName);
  232.   printf("AuthKey  = %s\n", VarAuthKey);
  233.   return(1);
  234. }
  235.  
  236. static int ShowVersion()
  237. {
  238.   extern char *VarVersion[];
  239.  
  240.   printf("%s\n", VarVersion);
  241.   return(1);
  242. }
  243.  
  244. static int ShowLogList()
  245. {
  246.   ListLog();
  247.   return(1);
  248. }
  249.  
  250. extern int ShowIfilter(), ShowOfilter(), ShowDfilter();
  251.  
  252. struct cmdtab ShowCommands[] = {
  253.   { "auth",     NULL,     ShowAuthKey,       "Show auth name/key",
  254.     StrNull, },
  255.   { "ccp",      NULL,     ReportCcpStatus,   "Show CCP status",
  256.     StrNull, },
  257.   { "compress", NULL,     ReportCompress,    "Show compression statictics",
  258.     StrNull },
  259.   { "debug",    NULL,      ShowDebugLevel,    "Show current debug level",
  260.     StrNull },
  261.   { "dfilter",  NULL,     ShowDfilter,       "Show Demand filters",
  262.     StrOption },
  263.   { "escape",   NULL,     ShowEscape,        "Show escape characters",
  264.     StrNull },
  265.   { "hdlc",    NULL,      ReportHdlcStatus,  "Show HDLC error summary",
  266.       StrNull },
  267.   { "ifilter",  NULL,     ShowIfilter,       "Show Input filters",
  268.     StrOption },
  269.   { "ipcp",     NULL,     ReportIpcpStatus,  "Show IPCP status",
  270.     StrNull, },
  271.   { "lcp",      NULL,     ReportLcpStatus,   "Show LCP status",
  272.     StrNull, },
  273.   { "log",      NULL,     ShowLogList,       "Show log records",
  274.     StrNull, },
  275.   { "mem",      NULL,     ShowMemMap,        "Show memory map",
  276.     StrNull, },
  277.   { "modem",    NULL,     ShowModemStatus,   "Show modem setups",
  278.     StrNull, },
  279.   { "ofilter",  NULL,     ShowOfilter,       "Show Output filters",
  280.     StrOption },
  281.   { "proto",    NULL,     ReportProtStatus,  "Show protocol summary",
  282.     StrNull, },
  283.   { "route",    NULL,     ShowRoute,         "Show routing table",
  284.     StrNull, },
  285.   { "timeout",  NULL,      ShowTimeout,       "Show Idle timeout value",
  286.     StrNull, },
  287.   { "version",  NULL,      ShowVersion,       "Show version string",
  288.     StrNull, },
  289.   { "help",     "?",      HelpCommand,       "Display this message",
  290.     StrNull, (void *)ShowCommands },
  291.   { NULL,       NULL,     NULL },
  292. };
  293.  
  294. struct cmdtab *
  295. FindCommand(cmds, str, pmatch)
  296. struct cmdtab *cmds;
  297. char *str;
  298. int *pmatch;
  299. {
  300.   int nmatch = 0;
  301.   int len = strlen(str);
  302.   struct cmdtab *found = NULL;
  303.  
  304.   while (cmds->func) {
  305.     if (cmds->name && strncmp(str, cmds->name, len) == 0) {
  306.       nmatch++;
  307.       found = cmds;
  308.     } else if (cmds->alias && strncmp(str, cmds->alias, len) == 0) {
  309.       nmatch++;
  310.       found = cmds;
  311.     }
  312.     cmds++;
  313.   }
  314.   *pmatch = nmatch;
  315.   return(found);
  316. }
  317.  
  318. int
  319. FindExec(cmdlist, argc, argv)
  320. struct cmdtab *cmdlist;
  321. int argc;
  322. char **argv;
  323. {
  324.   struct cmdtab *cmd;
  325.   int val = 1;
  326.   int nmatch;
  327.  
  328.   cmd = FindCommand(cmdlist, *argv, &nmatch);
  329.   if (nmatch > 1)
  330.     printf("Anbiguous.\n");
  331.   else if (cmd)
  332.     val = (cmd->func)(cmd, --argc, ++argv, cmd->args);
  333.   else
  334.     printf("what?\n");
  335.   return(val);
  336. }
  337.  
  338. void
  339. Prompt(flag)
  340. int flag;
  341. {
  342.   if (!(mode & MODE_INTER))
  343.     return;
  344.   if (flag) printf("\n");
  345.   if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK)
  346.     printf("PPP> ");
  347.   else
  348.     printf("ppp> ");
  349.   fflush(stdout);
  350. }
  351.  
  352. void
  353. DecodeCommand(buff, nb, prompt)
  354. char *buff;
  355. int nb;
  356. int prompt;
  357. {
  358.   char *vector[20];
  359.   char **argv;
  360.   int argc, val;
  361.   char *cp;
  362.  
  363.   val = 1;
  364.   if (nb > 0) {
  365.     cp = buff + strcspn(buff, "\r\n");
  366.     if (cp)
  367.       *cp = '\0';
  368.     {
  369.       argc = MakeArgs(buff, &vector);
  370.       argv = vector;
  371.  
  372.       if (argc > 0)
  373.         val = FindExec(Commands, argc, argv);
  374.     }
  375.   }
  376.   if (val && prompt)
  377.     Prompt(0);
  378. }
  379.  
  380. static int
  381. ShowCommand(list, argc, argv)
  382. struct cmdtab *list;
  383. int argc;
  384. char **argv;
  385. {
  386.   int val = 1;
  387.  
  388.   if (argc > 0)
  389.     val = FindExec(ShowCommands, argc, argv);
  390.   else
  391.     printf("Use ``show ?'' to get a list.\n");
  392.   return(val);
  393. }
  394.  
  395. static int
  396. TerminalCommand()
  397. {
  398.   if (LcpFsm.state > ST_CLOSED) {
  399.     printf("LCP state is [%s]\n", StateNames[LcpFsm.state]);
  400.     return(1);
  401.   }
  402.   if (!IsInteractive())
  403.     return(1);
  404.   modem = OpenModem(mode);
  405.   if (modem < 0) {
  406.     printf("failed to open modem.\n");
  407.     modem = 0;
  408.     return(1);
  409.   }
  410.   printf("Enter to terminal mode.\n");
  411.   printf("Type `~?' for help.\n");
  412.   TtyTermMode();
  413.   return(0);
  414. }
  415.  
  416. static int
  417. QuitCommand(list, argc, argv)
  418. struct cmdtab *list;
  419. int argc;
  420. char **argv;
  421. {
  422.   if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) {
  423.     if (argc > 0) {
  424.       Cleanup(EX_NORMAL);
  425.     } else {
  426.       close(netfd);
  427.       close(1);
  428.       netfd = -1;
  429.       mode &= ~MODE_INTER;
  430.     }
  431.   } else
  432.     Cleanup(EX_NORMAL);
  433.   return(1);
  434. }
  435.  
  436. static int
  437. CloseCommand()
  438. {
  439.   LcpClose();
  440.   return(1);
  441. }
  442.  
  443. static int
  444. DownCommand()
  445. {
  446.   LcpDown();
  447.   return(1);
  448. }
  449.  
  450. static int validspeed[] = {
  451.   1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 0
  452. };
  453.  
  454. static int SetModemSpeed(list, argc, argv)
  455. struct cmdtab *list;
  456. int argc;
  457. char **argv;
  458. {
  459.   int speed;
  460.   int *sp;
  461.  
  462.   if (argc > 0) {
  463.     speed = atoi(*argv);
  464.     for (sp = validspeed; *sp; sp++) {
  465.       if (*sp == speed) {
  466.     VarSpeed = speed;
  467.     return(1);
  468.       }
  469.     }
  470.     printf("invalid speed.\n");
  471.   }
  472.   return(1);
  473. }
  474.  
  475. static int SetModemParity(list, argc, argv)
  476. struct cmdtab *list;
  477. int argc;
  478. char **argv;
  479. {
  480.   int parity;
  481.  
  482.   if (argc > 0) {
  483.     parity = ChangeParity(*argv);
  484.     if (parity < 0)
  485.       printf("Invalid parity.\n");
  486.     else
  487.       VarParity = parity;
  488.   }
  489.   return(1);
  490. }
  491.  
  492. static int
  493. SetDebugLevel(list, argc, argv)
  494. struct cmdtab *list;
  495. int argc;
  496. char **argv;
  497. {
  498.   int level, w;
  499.  
  500.   for (level = 0; argc-- > 0; argv++) {
  501.     if (isdigit(**argv)) {
  502.       w = atoi(*argv);
  503.       if (w < 0 || w >= MAXLOGLEVEL) {
  504.     printf("invalid log level.\n");
  505.     break;
  506.       } else
  507.     level |= (1 << w);
  508.     } else {
  509.       for (w = 0; w < MAXLOGLEVEL; w++) {
  510.     if (strcasecmp(*argv, LogLevelName[w]) == 0) {
  511.       level |= (1 << w);
  512.       continue;
  513.     }
  514.       }
  515.     }
  516.   }
  517.   loglevel = level;
  518.   return(1);
  519. }
  520.  
  521. static int
  522. SetEscape(list, argc, argv)
  523. struct cmdtab *list;
  524. int argc;
  525. char **argv;
  526. {
  527.   int code;
  528.  
  529.   for (code = 0; code < 33; code++)
  530.     EscMap[code] = 0;
  531.   while (argc-- > 0) {
  532.     sscanf(*argv++, "%x", &code);
  533.     code &= 0xff;
  534.     EscMap[code >> 3] |= (1 << (code&7));
  535.     EscMap[32] = 1;
  536.   }
  537.   return(1);
  538. }
  539.  
  540. static int
  541. SetInitialMRU(list, argc, argv)
  542. struct cmdtab *list;
  543. int argc;
  544. char **argv;
  545. {
  546.   int mru;
  547.  
  548.   if (argc > 0) {
  549.     mru = atoi(*argv);
  550.     if (mru < 100)
  551.       printf("given value is too small.\n");
  552.     else if (mru > MAX_MRU)
  553.       printf("given value is too big.\n");
  554.     else
  555.       VarMRU = mru;
  556.   }
  557.   return(1);
  558. }
  559.  
  560. static int
  561. SetIdleTimeout(list, argc, argv)
  562. struct cmdtab *list;
  563. int argc;
  564. char **argv;
  565. {
  566.   if (argc-- > 0) {
  567.     VarIdleTimeout = atoi(*argv++);
  568.     if (argc > 0)
  569.       VarLqrTimeout = atoi(*argv);
  570.   }
  571.   return(1);
  572. }
  573.  
  574. struct in_addr
  575. GetIpAddr(cp)
  576. char *cp;
  577. {
  578.   struct hostent *hp;
  579.   struct in_addr ipaddr;
  580.  
  581.   hp = gethostbyname(cp);
  582.   if (hp && hp->h_addrtype == AF_INET)
  583.     bcopy(hp->h_addr, &ipaddr, hp->h_length);
  584.   else if (inet_aton(cp, &ipaddr) == 0)
  585.     ipaddr.s_addr = 0;
  586.   return(ipaddr);
  587. }
  588.  
  589. static int
  590. SetInterfaceAddr(list, argc, argv)
  591. struct cmdtab *list;
  592. int argc;
  593. char **argv;
  594. {
  595.   int width;
  596.  
  597.   DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L;
  598.   if (argc > 0) {
  599.     ParseAddr(argc, argv++,
  600.       &DefMyAddress.ipaddr, &DefMyAddress.mask, &DefMyAddress.width);
  601.     if (--argc > 0) {
  602.       ParseAddr(argc, argv++,
  603.     &DefHisAddress.ipaddr, &DefHisAddress.mask, &DefHisAddress.width);
  604.       if (--argc > 0) {
  605.         ifnetmask = GetIpAddr(*argv);
  606.       }
  607.     }
  608.   }
  609.   /*
  610.    * For backwards compatibility, 0.0.0.0 means any address.
  611.    */
  612.   if (DefMyAddress.ipaddr.s_addr == 0) {
  613.     DefMyAddress.mask.s_addr = 0;
  614.     DefMyAddress.width = 0;
  615.   }
  616.   if (DefHisAddress.ipaddr.s_addr == 0) {
  617.     DefHisAddress.mask.s_addr = 0;
  618.     DefHisAddress.width = 0;
  619.   }
  620.  
  621.   if ((mode & MODE_AUTO) |
  622.     ((mode & MODE_DEDICATED) && dstsystem)) {
  623.     OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask);
  624.   }
  625.   return(1);
  626. }
  627.  
  628.  
  629. #define    VAR_AUTHKEY    0
  630. #define    VAR_DIAL    1
  631. #define    VAR_LOGIN    2
  632. #define    VAR_AUTHNAME    3
  633. #define    VAR_DEVICE    4
  634. #define    VAR_ACCMAP    5
  635. #define    VAR_PHONE    6
  636.  
  637. static int
  638. SetVariable(list, argc, argv, param)
  639. struct cmdtab *list;
  640. int argc;
  641. char **argv;
  642. int param;
  643. {
  644.   u_long map;
  645.  
  646.   if (argc > 0) {
  647.     switch (param) {
  648.     case VAR_AUTHKEY:
  649.       strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1);
  650.       break;
  651.     case VAR_AUTHNAME:
  652.       strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1);
  653.       break;
  654.     case VAR_DIAL:
  655.       strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1);
  656.       break;
  657.     case VAR_LOGIN:
  658.       strncpy(VarLoginScript, *argv, sizeof(VarDialScript)-1);
  659.       break;
  660.     case VAR_DEVICE:
  661.       strncpy(VarDevice, *argv, sizeof(VarDevice)-1);
  662.       break;
  663.     case VAR_ACCMAP:
  664.       sscanf(*argv, "%x", &map);
  665.       VarAccmap = map;
  666.       break;
  667.     case VAR_PHONE:
  668.       strncpy(VarPhone, *argv, sizeof(VarPhone)-1);
  669.       break;
  670.     }
  671.   }
  672.   return(1);
  673. }
  674.  
  675. static int SetOpenMode(list, argc, argv)
  676. struct cmdtab *list;
  677. int argc;
  678. char **argv;
  679. {
  680.   if (argc > 0) {
  681.     if (strcmp(*argv, "active") == 0)
  682.       VarOpenMode = OPEN_ACTIVE;
  683.     else if (strcmp(*argv, "passive") == 0)
  684.       VarOpenMode = OPEN_PASSIVE;
  685.     else
  686.       printf("Invalid mode.\n");
  687.   }
  688.   return(1);
  689. }
  690.  
  691. static char StrChatStr[] = "chat-script";
  692. static char StrValue[] = "value";
  693.  
  694. extern int SetIfilter(), SetOfilter(), SetDfilter();
  695.  
  696. struct cmdtab SetCommands[] = {
  697.   { "accmap",   NULL,      SetVariable,      "Set accmap value",
  698.     "hex-value",    (void *)VAR_ACCMAP },
  699.   { "authkey",  "key",     SetVariable,      "Set authentication key",
  700.     "key",        (void *)VAR_AUTHKEY },
  701.   { "authname", NULL,     SetVariable,    "Set authentication name",
  702.     "name",        (void *)VAR_AUTHNAME },
  703.   { "debug",    NULL,      SetDebugLevel,  "Set debug level",
  704.     StrValue },
  705.   { "device",     "line", SetVariable, "Set modem device name",
  706.     "device-name",    (void *)VAR_DEVICE },
  707.   { "dfilter",  NULL,     SetDfilter,  "Set demand filter",
  708.         "..." },
  709.   { "dial",     NULL,     SetVariable,      "Set dialing script",
  710.     StrChatStr,    (void *)VAR_DIAL },
  711.   { "escape",   NULL,      SetEscape,       "Set escape characters",
  712.         "hex-digit ..."},
  713.   { "ifaddr",   NULL,   SetInterfaceAddr,  "Set destination address",
  714.     "src-addr dst-addr netmask" },
  715.   { "ifilter",  NULL,     SetIfilter,  "Set input filter",
  716.         "..." },
  717.   { "login",    NULL,     SetVariable,    "Set login script",
  718.      StrChatStr,    (void *)VAR_LOGIN },
  719.   { "mru",      "mtu",    SetInitialMRU,  "Set Initial MRU value",
  720.     StrValue },
  721.   { "ofilter",  NULL,      SetOfilter,      "Set output filter",
  722.         "..." },
  723.   { "openmode", NULL,      SetOpenMode,      "Set open mode",
  724.     "[active|passive]" },
  725.   { "parity",   NULL,     SetModemParity, "Set modem parity",
  726.     "[odd|even|none]" },
  727.   { "phone",    NULL,     SetVariable,      "Set telephone number",
  728.         "phone-number",    (void *)VAR_PHONE },
  729.   { "speed",    NULL,     SetModemSpeed,  "Set modem speed",
  730.     "speed" },
  731.   { "timeout",  NULL,     SetIdleTimeout, "Set Idle timeout",
  732.     StrValue },
  733.   { "help",     "?",      HelpCommand,    "Display this message",
  734.     StrNull, (void *)SetCommands },
  735.   { NULL,       NULL,     NULL },
  736. };
  737.  
  738. static int
  739. SetCommand(list, argc, argv)
  740. struct cmdtab *list;
  741. int argc;
  742. char **argv;
  743. {
  744.   int val = 1;
  745.  
  746.   if (argc > 0)
  747.     val = FindExec(SetCommands, argc, argv);
  748.   else
  749.     printf("Use ``set ?'' to get a list.\n");
  750.   return(val);
  751. }
  752.  
  753.  
  754. static int
  755. AddCommand(list, argc, argv)
  756. struct cmdtab *list;
  757. int argc;
  758. char **argv;
  759. {
  760.   struct in_addr dest, gateway, netmask;
  761.  
  762.   if (argc == 3) {
  763.     dest = GetIpAddr(argv[0]);
  764.     netmask = GetIpAddr(argv[1]);
  765.     if (strcmp(argv[2], "HISADDR") == 0)
  766.       gateway = IpcpInfo.his_ipaddr;
  767.     else
  768.       gateway = GetIpAddr(argv[2]);
  769.     OsSetRoute(RTM_ADD, dest, gateway, netmask);
  770.   } else {
  771.     printf("Usage: %s %s\n", list->name, list->syntax);
  772.   }
  773.   return(1);
  774. }
  775.  
  776. static int
  777. DeleteCommand(list, argc, argv)
  778. struct cmdtab *list;
  779. int argc;
  780. char **argv;
  781. {
  782.   struct in_addr dest, gateway, netmask;
  783.  
  784.   if (argc >= 2) {
  785.     dest = GetIpAddr(argv[0]);
  786.     if (strcmp(argv[1], "HISADDR") == 0)
  787.       gateway = IpcpInfo.his_ipaddr;
  788.     else
  789.       gateway = GetIpAddr(argv[1]);
  790.     netmask.s_addr = 0;
  791.     if (argc == 3) {
  792.       if (inet_aton(argv[1], &netmask) == 0) {
  793.     printf("bad netmask value.\n");
  794.     return(1);
  795.       }
  796.     }
  797.     OsSetRoute(RTM_DELETE, dest, gateway, netmask);
  798.   } else if (argc == 1 && strcmp(argv[0], "ALL") == 0) {
  799.     DeleteIfRoutes(0);
  800.   } else {
  801.     printf("Usage: %s %s\n", list->name, list->syntax);
  802.   }
  803.   return(1);
  804. }
  805.  
  806.